package com.example.administrator.exkotlin.base

import com.example.administrator.exkotlin.base.`object`.IStudy
import java.lang.StringBuilder

/**
 * koltin中的标准表达式
 * run
 * with
 * let
 * */
class Standard {

    /**
     * with函数的java流程
     * */
    fun ex_with_java() {
        val list = listOf<String>("apple", "banana", "oringe", "pear")
        val stringBuilder = StringBuilder()
        stringBuilder.append("水果有：")
        stringBuilder.append("\r\n")
        for (s in list) {
            stringBuilder.append(s)
            stringBuilder.append("\r\n")
        }
        println(stringBuilder.toString())
    }

    /**
     * with(obj){}函数，第一个参数为任意类型的对象，第二个参数为lambada表达式
     * 将表达式最后一行的结果作为返回值
     * 整个表达式中持有第一个对象的上下文
     * 作用为不用重复的使用一个对象，可以在表达式中使用上下文对应对象的函数，精简代码
     * */
    fun ex_with_koltin() {
        val list = listOf<String>("apple", "banana", "oringe", "pear")
        val result = with(StringBuilder()) {
            append("水果有：")
            for (s in list) {
                append(s)
                append("\r\n")
            }
            toString()
        }
        println(result)
    }


    /**
     * run函数
     * 与with函数基本相同
     * 1.区别在于不能单独使用，必须是调用某个对象的run函数才行
     * 2.run函数只接受一个lambda表达式，表达式中，提供调用对象的上下文
     * 3.同样将表达式最后一句的结果作为返回值
     *
     * 主要就是进一步精简了with函数，在某些情况下可以方便一点
     * */
    fun ex_run_kotin() {
        val list = listOf<String>("apple", "banana", "oringe", "pear")
        val stringBuilder = StringBuilder()
        val result = stringBuilder.run {
            append("水果有：")
            for (s in list) {
                append(s)
                append("\r\n")
            }
            toString()
        }
        println(result)
    }

    /**
     * apply函数
     * 与run函数极其相似
     * 1.不能单独使用，必须是调用某个对象的run函数才行
     * 2.applty函数只接受一个lambda表达式，表达式中，提供调用对象的上下文
     * 3.返回对象本身，而不是将最后一句作为返回值
     * */
    fun ex_apply_kotin() {
        val list = listOf<String>("apple", "banana", "oringe", "pear")
        val stringBuilder = StringBuilder()
        val result = stringBuilder.apply {
            append("水果有：")
            for (s in list) {
                append(s)
                append("\r\n")
            }
        }
        println(result.toString())
    }

    /**
     * let函数，将对象本身传递到lambda表达中
     * 因此在之前只需要做一次?.来判空即可
     * */
    fun ex_let_koltin(study: IStudy?) {
        //这种方式有点啰嗦，相当于每次都进行了一次判断
        study?.write("")
        study?.read("")

        //let函数，将对象本身传递到lambda表达中 因此在之前只需要做一次?.来判空即可
        study?.let { study2 ->
            {
                study2.read("")
                study2.write("")
            }
        }

    }
}